ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಮುಂದಿನ ವಿಕಾಸವನ್ನು ಅನ್ವೇಷಿಸಿ: ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್. ಬಿಲ್ಡ್-ಟೈಮ್ ಮಾಡ್ಯೂಲ್ ರೆಸಲ್ಯೂಶನ್, ಮ್ಯಾಕ್ರೋಗಳು ಮತ್ತು ಜಾಗತಿಕ ಡೆವಲಪರ್‌ಗಳಿಗಾಗಿ ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್‌ಗಳ ಕುರಿತ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳಲ್ಲಿ ಕ್ರಾಂತಿ: ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನ ಆಳವಾದ ನೋಟ
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯು ನಿರಂತರ ವಿಕಾಸದ ಸ್ಥಿತಿಯಲ್ಲಿದೆ. ಬ್ರೌಸರ್‌ಗಳಿಗಾಗಿ ಒಂದು ಸರಳ ಸ್ಕ್ರಿಪ್ಟಿಂಗ್ ಭಾಷೆಯಾಗಿ ತನ್ನ ವಿನಮ್ರ ಆರಂಭದಿಂದ, ಇದು ಜಾಗತಿಕ ಶಕ್ತಿಯಾಗಿ ಬೆಳೆದಿದೆ, ಸಂಕೀರ್ಣ ವೆಬ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಿಂದ ಹಿಡಿದು ಸರ್ವರ್-ಸೈಡ್ ಮೂಲಸೌಕರ್ಯದವರೆಗೆ ಎಲ್ಲವನ್ನೂ ಚಾಲನೆ ಮಾಡುತ್ತಿದೆ. ಈ ವಿಕಾಸದ ಮೂಲಾಧಾರವೆಂದರೆ ಅದರ ಮಾಡ್ಯೂಲ್ ಸಿಸ್ಟಮ್, ES ಮಾಡ್ಯೂಲ್ಸ್ (ESM) ನ ಪ್ರಮಾಣೀಕರಣ. ಆದರೂ, ESM ಸಾರ್ವತ್ರಿಕ ಮಾನದಂಡವಾಗಿ ಮಾರ್ಪಟ್ಟಿದ್ದರೂ, ಹೊಸ ಸವಾಲುಗಳು ಹೊರಹೊಮ್ಮಿವೆ, ಸಾಧ್ಯವಿರುವ ಗಡಿಗಳನ್ನು ತಳ್ಳುತ್ತಿವೆ. ಇದು TC39 ನಿಂದ ಒಂದು ಅತ್ಯಾಕರ್ಷಕ ಮತ್ತು ಸಂಭಾವ್ಯವಾಗಿ ಪರಿವರ್ತಕ ಹೊಸ ಪ್ರಸ್ತಾವನೆಗೆ ಕಾರಣವಾಗಿದೆ: ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್.
ಪ್ರಸ್ತುತ ಸ್ಟ್ಯಾಂಡರ್ಡ್ಸ್ ಟ್ರ್ಯಾಕ್ ಮೂಲಕ ಪ್ರಗತಿಯಲ್ಲಿರುವ ಈ ಪ್ರಸ್ತಾವನೆಯು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅವಲಂಬನೆಗಳನ್ನು ಹೇಗೆ ನಿಭಾಯಿಸಬಹುದು ಎಂಬುದರಲ್ಲಿ ಒಂದು ಮೂಲಭೂತ ಬದಲಾವಣೆಯನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಇದು 'ಬಿಲ್ಡ್ ಟೈಮ್' ಅಥವಾ 'ಸೋರ್ಸ್ ಫೇಸ್' ಪರಿಕಲ್ಪನೆಯನ್ನು ನೇರವಾಗಿ ಭಾಷೆಗೆ ಪರಿಚಯಿಸುತ್ತದೆ, ಡೆವಲಪರ್‌ಗಳಿಗೆ ಕಂಪೈಲೇಶನ್ ಸಮಯದಲ್ಲಿ ಮಾತ್ರ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತದೆ, ಇದು ಅಂತಿಮ ರನ್‌ಟೈಮ್ ಕೋಡ್‌ನ ಭಾಗವಾಗದೆ ಅದರ ಮೇಲೆ ಪ್ರಭಾವ ಬೀರುತ್ತದೆ. ಇದು ನೇಟಿವ್ ಮ್ಯಾಕ್ರೋಗಳು, ಶೂನ್ಯ-ವೆಚ್ಚದ ಟೈಪ್ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್‌ಗಳು, ಮತ್ತು ಸುಗಮವಾದ ಬಿಲ್ಡ್-ಟೈಮ್ ಕೋಡ್ ಜನರೇಷನ್‌ನಂತಹ ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯಗಳಿಗೆ ದಾರಿ ಮಾಡಿಕೊಡುತ್ತದೆ, ಎಲ್ಲವೂ ಒಂದು ಪ್ರಮಾಣಿತ, ಸುರಕ್ಷಿತ ಚೌಕಟ್ಟಿನೊಳಗೆ.
ಪ್ರಪಂಚದಾದ್ಯಂತದ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಈ ಪ್ರಸ್ತಾವನೆಯನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೂಲಿಂಗ್, ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್ ಆರ್ಕಿಟೆಕ್ಚರ್‌ನಲ್ಲಿನ ಮುಂದಿನ ನಾವೀನ್ಯತೆಯ ಅಲೆಗೆ ಸಿದ್ಧರಾಗಲು ಪ್ರಮುಖವಾಗಿದೆ. ಈ ಸಮಗ್ರ ಮಾರ್ಗದರ್ಶಿಯು ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ ಎಂದರೇನು, ಅವುಗಳು ಪರಿಹರಿಸುವ ಸಮಸ್ಯೆಗಳು, ಅವುಗಳ ಪ್ರಾಯೋಗಿಕ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಇಡೀ ಜಾಗತಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮುದಾಯದ ಮೇಲೆ ಅವುಗಳು ಬೀರಲಿರುವ ಆಳವಾದ ಪರಿಣಾಮವನ್ನು ಅನ್ವೇಷಿಸುತ್ತದೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ಸಂಕ್ಷಿಪ್ತ ಇತಿಹಾಸ: ESM ಗೆ ದಾರಿ
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನ ಮಹತ್ವವನ್ನು ಶ್ಲಾಘಿಸಲು, ನಾವು ಮೊದಲು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್‌ಗಳ ಪ್ರಯಾಣವನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳಬೇಕು. ಅದರ ಇತಿಹಾಸದ ಬಹುಪಾಲು, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಸ್ಥಳೀಯ ಮಾಡ್ಯೂಲ್ ವ್ಯವಸ್ಥೆಯ ಕೊರತೆಯಿತ್ತು, ಇದು ಸೃಜನಶೀಲ ಆದರೆ ವಿಭಜಿತ ಪರಿಹಾರಗಳ ಅವಧಿಗೆ ಕಾರಣವಾಯಿತು.
ಗ್ಲೋಬಲ್‌ಗಳು ಮತ್ತು IIFE ಗಳ ಯುಗ
ಆರಂಭದಲ್ಲಿ, ಡೆವಲಪರ್‌ಗಳು HTML ಫೈಲ್‌ನಲ್ಲಿ ಬಹು <script> ಟ್ಯಾಗ್‌ಗಳನ್ನು ಲೋಡ್ ಮಾಡುವ ಮೂಲಕ ಅವಲಂಬನೆಗಳನ್ನು ನಿರ್ವಹಿಸುತ್ತಿದ್ದರು. ಇದು ಜಾಗತಿಕ ನೇಮ್‌ಸ್ಪೇಸ್ ಅನ್ನು (ಬ್ರೌಸರ್‌ಗಳಲ್ಲಿ window ಆಬ್ಜೆಕ್ಟ್) ಕಲುಷಿತಗೊಳಿಸಿತು, ಇದು ವೇರಿಯಬಲ್ ಘರ್ಷಣೆಗಳು, ಅನಿರೀಕ್ಷಿತ ಲೋಡಿಂಗ್ ಆರ್ಡರ್‌ಗಳು ಮತ್ತು ನಿರ್ವಹಣೆಯ ದುಃಸ್ವಪ್ನಕ್ಕೆ ಕಾರಣವಾಯಿತು. ಇದನ್ನು ತಗ್ಗಿಸಲು ಒಂದು ಸಾಮಾನ್ಯ ಮಾದರಿಯೆಂದರೆ ತಕ್ಷಣವೇ ಆಹ್ವಾನಿಸಲಾದ ಫಂಕ್ಷನ್ ಎಕ್ಸ್‌ಪ್ರೆಶನ್ (IIFE), ಇದು ಸ್ಕ್ರಿಪ್ಟ್‌ನ ವೇರಿಯಬಲ್‌ಗಳಿಗೆ ಖಾಸಗಿ ಸ್ಕೋಪ್ ಅನ್ನು ರಚಿಸಿತು, ಅವುಗಳನ್ನು ಜಾಗತಿಕ ಸ್ಕೋಪ್‌ಗೆ ಸೋರಿಕೆಯಾಗದಂತೆ ತಡೆಯುತ್ತದೆ.
ಸಮುದಾಯ-ಚಾಲಿತ ಮಾನದಂಡಗಳ ಉದಯ
ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಹೆಚ್ಚು ಸಂಕೀರ್ಣವಾದಂತೆ, ಸಮುದಾಯವು ಹೆಚ್ಚು ದೃಢವಾದ ಪರಿಹಾರಗಳನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಿತು:
- ಕಾಮನ್‌ಜೆಎಸ್ (CJS): Node.js ನಿಂದ ಜನಪ್ರಿಯಗೊಳಿಸಲ್ಪಟ್ಟ CJS, ಸಿಂಕ್ರೊನಸ್
require()ಫಂಕ್ಷನ್ ಮತ್ತುexportsಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಬಳಸುತ್ತದೆ. ಇದನ್ನು ಸರ್ವರ್‌ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ, ಅಲ್ಲಿ ಫೈಲ್‌ಸಿಸ್ಟಮ್‌ನಿಂದ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಓದುವುದು ವೇಗದ, ಬ್ಲಾಕಿಂಗ್ ಕಾರ್ಯಾಚರಣೆಯಾಗಿದೆ. ಅದರ ಸಿಂಕ್ರೊನಸ್ ಸ್ವರೂಪವು ಬ್ರೌಸರ್‌ಗೆ ಕಡಿಮೆ ಸೂಕ್ತವಾಗಿದೆ, ಅಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿರುತ್ತವೆ. - ಅಸಿಂಕ್ರೊನಸ್ ಮಾಡ್ಯೂಲ್ ಡೆಫಿನಿಷನ್ (AMD): ಬ್ರೌಸರ್‌ಗಾಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾದ AMD (ಮತ್ತು ಅದರ ಅತ್ಯಂತ ಜನಪ್ರಿಯ ಅನುಷ್ಠಾನ, RequireJS) ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ಲೋಡ್ ಮಾಡುತ್ತದೆ. ಇದರ ಸಿಂಟ್ಯಾಕ್ಸ್ ಕಾಮನ್‌ಜೆಎಸ್‌ಗಿಂತ ಹೆಚ್ಚು ವಿವರಣಾತ್ಮಕವಾಗಿತ್ತು ಆದರೆ ಕ್ಲೈಂಟ್-ಸೈಡ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳಲ್ಲಿ ನೆಟ್‌ವರ್ಕ್ ಲೇಟೆನ್ಸಿ ಸಮಸ್ಯೆಯನ್ನು ಪರಿಹರಿಸಿತು.
ಪ್ರಮಾಣೀಕರಣ: ES ಮಾಡ್ಯೂಲ್‌ಗಳು (ESM)
ಅಂತಿಮವಾಗಿ, ECMAScript 2015 (ES6) ಸ್ಥಳೀಯ, ಪ್ರಮಾಣಿತ ಮಾಡ್ಯೂಲ್ ವ್ಯವಸ್ಥೆಯನ್ನು ಪರಿಚಯಿಸಿತು: ES ಮಾಡ್ಯೂಲ್‌ಗಳು. ESM ಶುದ್ಧ, ಘೋಷಣಾತ್ಮಕ ಸಿಂಟ್ಯಾಕ್ಸ್ (import ಮತ್ತು export) ನೊಂದಿಗೆ ಎರಡೂ ಪ್ರಪಂಚದ ಅತ್ಯುತ್ತಮವನ್ನು ತಂದಿತು, ಇದನ್ನು ಸ್ಥಿರವಾಗಿ ವಿಶ್ಲೇಷಿಸಬಹುದು. ಈ ಸ್ಥಿರ ಸ್ವಭಾವವು ಬಂಡ್ಲರ್‌ಗಳಂತಹ ಪರಿಕರಗಳಿಗೆ ಕೋಡ್ ರನ್ ಆಗುವ ಮೊದಲು ಟ್ರೀ-ಶೇಕಿಂಗ್ (ಬಳಕೆಯಾಗದ ಕೋಡ್ ತೆಗೆದುಹಾಕುವುದು) ನಂತಹ ಆಪ್ಟಿಮೈಸೇಶನ್‌ಗಳನ್ನು ಮಾಡಲು ಅನುಮತಿಸುತ್ತದೆ. ESM ಅನ್ನು ಅಸಿಂಕ್ರೊನಸ್ ಆಗಿ ವಿನ್ಯಾಸಗೊಳಿಸಲಾಗಿದೆ ಮತ್ತು ಈಗ ಬ್ರೌಸರ್‌ಗಳು ಮತ್ತು Node.js জুড়ে ಸಾರ್ವತ್ರಿಕ ಮಾನದಂಡವಾಗಿದೆ, ಇದು ವಿಭಜಿತ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯನ್ನು ಒಂದುಗೂಡಿಸುತ್ತದೆ.
ಆಧುನಿಕ ES ಮಾಡ್ಯೂಲ್‌ಗಳ ಗುಪ್ತ ಮಿತಿಗಳು
ESM ಒಂದು ದೊಡ್ಡ ಯಶಸ್ಸು, ಆದರೆ ಅದರ ವಿನ್ಯಾಸವು ಕೇವಲ ರನ್‌ಟೈಮ್ ವರ್ತನೆಯ ಮೇಲೆ ಕೇಂದ್ರೀಕೃತವಾಗಿದೆ. ಒಂದು import ಹೇಳಿಕೆಯು ಅಪ್ಲಿಕೇಶನ್ ರನ್ ಆಗುವಾಗ ತರಬೇಕಾದ, ಪಾರ್ಸ್ ಮಾಡಬೇಕಾದ ಮತ್ತು ಕಾರ್ಯಗತಗೊಳಿಸಬೇಕಾದ ಅವಲಂಬನೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಈ ರನ್‌ಟೈಮ್-ಕೇಂದ್ರಿತ ಮಾದರಿಯು, ಶಕ್ತಿಯುತವಾಗಿದ್ದರೂ, ಹಲವಾರು ಸವಾಲುಗಳನ್ನು ಸೃಷ್ಟಿಸುತ್ತದೆ, ಇವುಗಳನ್ನು ಪರಿಸರ ವ್ಯವಸ್ಥೆಯು ಬಾಹ್ಯ, ಪ್ರಮಾಣಿತವಲ್ಲದ ಪರಿಕರಗಳೊಂದಿಗೆ ಪರಿಹರಿಸುತ್ತಿದೆ.
ಸಮಸ್ಯೆ 1: ಬಿಲ್ಡ್-ಟೈಮ್ ಅವಲಂಬನೆಗಳ ಪ್ರಸರಣ
ಆಧುನಿಕ ವೆಬ್ ಅಭಿವೃದ್ಧಿಯು ಬಿಲ್ಡ್ ಹಂತದ ಮೇಲೆ ಹೆಚ್ಚು ಅವಲಂಬಿತವಾಗಿದೆ. ನಾವು ನಮ್ಮ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಉತ್ಪಾದನೆಗಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು TypeScript, Babel, Vite, Webpack, ಮತ್ತು PostCSS ನಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸುತ್ತೇವೆ. ಈ ಪ್ರಕ್ರಿಯೆಯು ಅನೇಕ ಅವಲಂಬನೆಗಳನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ, ಅದು ಕೇವಲ ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ಬೇಕಾಗುತ್ತದೆ, ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಅಲ್ಲ.
TypeScript ಅನ್ನು ಪರಿಗಣಿಸಿ. ನೀವು import { type User } from './types' ಎಂದು ಬರೆದಾಗ, ನೀವು ರನ್‌ಟೈಮ್ ಸಮಾನತೆಯನ್ನು ಹೊಂದಿರದ ಒಂದು ಘಟಕವನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುತ್ತಿದ್ದೀರಿ. TypeScript ಕಂಪೈಲರ್ ಈ ಇಂಪೋರ್ಟ್ ಮತ್ತು ಟೈಪ್ ಮಾಹಿತಿಯನ್ನು ಕಂಪೈಲೇಶನ್ ಸಮಯದಲ್ಲಿ ಅಳಿಸಿಹಾಕುತ್ತದೆ. ಆದಾಗ್ಯೂ, ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಮಾಡ್ಯೂಲ್ ಸಿಸ್ಟಮ್ ದೃಷ್ಟಿಕೋನದಿಂದ, ಇದು ಕೇವಲ ಮತ್ತೊಂದು ಇಂಪೋರ್ಟ್ ಆಗಿದೆ. ಬಂಡ್ಲರ್‌ಗಳು ಮತ್ತು ಇಂಜಿನ್‌ಗಳು ಈ "ಟೈಪ್-ಮಾತ್ರ" ಇಂಪೋರ್ಟ್‌ಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಮತ್ತು ತಿರಸ್ಕರಿಸಲು ವಿಶೇಷ ತರ್ಕವನ್ನು ಹೊಂದಿರಬೇಕು, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯ ನಿರ್ದಿಷ್ಟತೆಯ ಹೊರಗೆ ಇರುವ ಪರಿಹಾರವಾಗಿದೆ.
ಸಮಸ್ಯೆ 2: ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್‌ಗಳ ಅನ್ವೇಷಣೆ
ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್ ಎನ್ನುವುದು ಅಭಿವೃದ್ಧಿಯ ಸಮಯದಲ್ಲಿ ಉನ್ನತ ಮಟ್ಟದ ಅನುಕೂಲವನ್ನು ಒದಗಿಸುವ ಒಂದು ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ ಆದರೆ ಯಾವುದೇ ರನ್‌ಟೈಮ್ ಓವರ್‌ಹೆಡ್ ಇಲ್ಲದೆ ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿ ಕೋಡ್‌ಗೆ ಕಂಪೈಲ್ ಆಗುತ್ತದೆ. ಒಂದು ಉತ್ತಮ ಉದಾಹರಣೆಯೆಂದರೆ ವ್ಯಾಲಿಡೇಶನ್ ಲೈಬ್ರರಿ. ನೀವು ಹೀಗೆ ಬರೆಯಬಹುದು:
validate(userSchema, userData);
ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ, ಇದು ಒಂದು ಫಂಕ್ಷನ್ ಕಾಲ್ ಮತ್ತು ವ್ಯಾಲಿಡೇಶನ್ ತರ್ಕದ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಯನ್ನು ಒಳಗೊಂಡಿರುತ್ತದೆ. ಭಾಷೆಯು ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ, ಸ್ಕೀಮಾವನ್ನು ವಿಶ್ಲೇಷಿಸಿ ಹೆಚ್ಚು ನಿರ್ದಿಷ್ಟ, ಇನ್‌ಲೈನ್ಡ್ ವ್ಯಾಲಿಡೇಶನ್ ಕೋಡ್ ಅನ್ನು ರಚಿಸಬಹುದಾದರೆ, ಅಂತಿಮ ಬಂಡಲ್‌ನಿಂದ ಸಾಮಾನ್ಯ `validate` ಫಂಕ್ಷನ್ ಕಾಲ್ ಮತ್ತು ಸ್ಕೀಮಾ ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ತೆಗೆದುಹಾಕಬಹುದಲ್ಲವೇ? ಇದನ್ನು ಪ್ರಮಾಣಿತ ರೀತಿಯಲ್ಲಿ ಮಾಡಲು ಪ್ರಸ್ತುತ ಅಸಾಧ್ಯ. ಸಂಪೂರ್ಣ `validate` ಫಂಕ್ಷನ್ ಮತ್ತು `userSchema` ಆಬ್ಜೆಕ್ಟ್ ಅನ್ನು ಕ್ಲೈಂಟ್‌ಗೆ ಕಳುಹಿಸಬೇಕು, ವ್ಯಾಲಿಡೇಶನ್ ಅನ್ನು ವಿಭಿನ್ನವಾಗಿ ನಿರ್ವಹಿಸಬಹುದಾಗಿದ್ದರೂ ಅಥವಾ ಪೂರ್ವ-ಕಂಪೈಲ್ ಮಾಡಬಹುದಾಗಿದ್ದರೂ ಸಹ.
ಸಮಸ್ಯೆ 3: ಪ್ರಮಾಣಿತ ಮ್ಯಾಕ್ರೋಗಳ ಅನುಪಸ್ಥಿತಿ
ಮ್ಯಾಕ್ರೋಗಳು Rust, Lisp, ಮತ್ತು Swift ನಂತಹ ಭಾಷೆಗಳಲ್ಲಿ ಒಂದು ಶಕ್ತಿಯುತ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ಅವು ಮೂಲಭೂತವಾಗಿ ಕಂಪೈಲ್ ಸಮಯದಲ್ಲಿ ಕೋಡ್ ಬರೆಯುವ ಕೋಡ್ ಆಗಿರುತ್ತವೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನಲ್ಲಿ, ನಾವು Babel ಪ್ಲಗಿನ್‌ಗಳು ಅಥವಾ SWC ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್‌ಗಳಂತಹ ಸಾಧನಗಳನ್ನು ಬಳಸಿ ಮ್ಯಾಕ್ರೋಗಳನ್ನು ಅನುಕರಿಸುತ್ತೇವೆ. ಅತ್ಯಂತ ಸರ್ವತ್ರ ಉದಾಹರಣೆಯೆಂದರೆ JSX:
const element = <h1>Hello, World</h1>;
ಇದು ಮಾನ್ಯವಾದ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಲ್ಲ. ಒಂದು ಬಿಲ್ಡ್ ಟೂಲ್ ಇದನ್ನು ಹೀಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ:
const element = React.createElement('h1', null, 'Hello, World');
ಈ ರೂಪಾಂತರವು ಶಕ್ತಿಯುತವಾಗಿದೆ ಆದರೆ ಸಂಪೂರ್ಣವಾಗಿ ಬಾಹ್ಯ ಟೂಲಿಂಗ್ ಅನ್ನು ಅವಲಂಬಿಸಿದೆ. ಈ ರೀತಿಯ ಸಿಂಟ್ಯಾಕ್ಸ್ ರೂಪಾಂತರವನ್ನು ನಿರ್ವಹಿಸುವ ಫಂಕ್ಷನ್ ಅನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಯಾವುದೇ ಸ್ಥಳೀಯ, ಭಾಷೆಯೊಳಗಿನ ಮಾರ್ಗವಿಲ್ಲ. ಈ ಪ್ರಮಾಣೀಕರಣದ ಕೊರತೆಯು ಸಂಕೀರ್ಣ ಮತ್ತು ಆಗಾಗ್ಗೆ ದುರ್ಬಲವಾದ ಟೂಲಿಂಗ್ ಸರಪಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ ಪರಿಚಯ: ಒಂದು ಮಾದರಿ ಬದಲಾವಣೆ
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ ಈ ಮಿತಿಗಳಿಗೆ ನೇರ ಉತ್ತರವಾಗಿದೆ. ಈ ಪ್ರಸ್ತಾವನೆಯು ಹೊಸ ಇಂಪೋರ್ಟ್ ಡಿಕ್ಲರೇಶನ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ, ಇದು ಬಿಲ್ಡ್-ಟೈಮ್ ಅವಲಂಬನೆಗಳನ್ನು ರನ್‌ಟೈಮ್ ಅವಲಂಬನೆಗಳಿಂದ ಸ್ಪಷ್ಟವಾಗಿ ಪ್ರತ್ಯೇಕಿಸುತ್ತದೆ.
ಹೊಸ ಸಿಂಟ್ಯಾಕ್ಸ್ ಸರಳ ಮತ್ತು ಅರ್ಥಗರ್ಭಿತವಾಗಿದೆ: import source.
import { MyType } from './types.js'; // ಒಂದು ಪ್ರಮಾಣಿತ, ರನ್‌ಟೈಮ್ ಇಂಪೋರ್ಟ್
import source { MyMacro } from './macros.js'; // ಒಂದು ಹೊಸ, ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್
ಮೂಲ ಪರಿಕಲ್ಪನೆ: ಹಂತಗಳ ಬೇರ್ಪಡಿಕೆ
ಕೋಡ್ ಮೌಲ್ಯಮಾಪನದ ಎರಡು ವಿಭಿನ್ನ ಹಂತಗಳನ್ನು ಔಪಚಾರಿಕಗೊಳಿಸುವುದು ಪ್ರಮುಖ ಆಲೋಚನೆಯಾಗಿದೆ:
- ಸೋರ್ಸ್ ಫೇಸ್ (ಬಿಲ್ಡ್ ಟೈಮ್): ಈ ಹಂತವು ಮೊದಲು ಸಂಭವಿಸುತ್ತದೆ, ಇದನ್ನು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ "ಹೋಸ್ಟ್" ನಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ (ಬಂಡ್ಲರ್, Node.js ಅಥವಾ Deno ನಂತಹ ರನ್‌ಟೈಮ್, ಅಥವಾ ಬ್ರೌಸರ್‌ನ ಡೆವಲಪ್‌ಮೆಂಟ್/ಬಿಲ್ಡ್ ಪರಿಸರ). ಈ ಹಂತದಲ್ಲಿ, ಹೋಸ್ಟ್
import sourceಘೋಷಣೆಗಳನ್ನು ಹುಡುಕುತ್ತದೆ. ನಂತರ ಅದು ಈ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ವಿಶೇಷ, ಪ್ರತ್ಯೇಕ ಪರಿಸರದಲ್ಲಿ ಲೋಡ್ ಮಾಡಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಈ ಮಾಡ್ಯೂಲ್‌ಗಳು ಅವುಗಳನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳುವ ಮಾಡ್ಯೂಲ್‌ಗಳ ಸೋರ್ಸ್ ಕೋಡ್ ಅನ್ನು ಪರಿಶೀಲಿಸಬಹುದು ಮತ್ತು ರೂಪಾಂತರಿಸಬಹುದು. - ರನ್‌ಟೈಮ್ ಫೇಸ್ (ಕಾರ್ಯಗತಗೊಳಿಸುವ ಸಮಯ): ಇದು ನಾವೆಲ್ಲರೂ ಚಿರಪರಿಚಿತವಾಗಿರುವ ಹಂತವಾಗಿದೆ. ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್ ಅಂತಿಮ, ಸಂಭಾವ್ಯವಾಗಿ ರೂಪಾಂತರಗೊಂಡ ಕೋಡ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ.
import sourceಮೂಲಕ ಆಮದು ಮಾಡಿಕೊಂಡ ಎಲ್ಲಾ ಮಾಡ್ಯೂಲ್‌ಗಳು ಮತ್ತು ಅವುಗಳನ್ನು ಬಳಸಿದ ಕೋಡ್ ಸಂಪೂರ್ಣವಾಗಿ ಹೋಗಿರುತ್ತದೆ; ಅವು ರನ್‌ಟೈಮ್ ಮಾಡ್ಯೂಲ್ ಗ್ರಾಫ್‌ನಲ್ಲಿ ಯಾವುದೇ ಕುರುಹುಗಳನ್ನು ಬಿಡುವುದಿಲ್ಲ.
ಇದನ್ನು ಭಾಷೆಯ ನಿರ್ದಿಷ್ಟತೆಯಲ್ಲಿ ನೇರವಾಗಿ ನಿರ್ಮಿಸಲಾದ ಪ್ರಮಾಣಿತ, ಸುರಕ್ಷಿತ ಮತ್ತು ಮಾಡ್ಯೂಲ್-ಅರಿವುಳ್ಳ ಪ್ರಿಪ್ರೊಸೆಸರ್ ಎಂದು ಯೋಚಿಸಿ. ಇದು ಸಿ ಪ್ರಿಪ್ರೊಸೆಸರ್‌ನಂತೆ ಕೇವಲ ಟೆಕ್ಸ್ಟ್ ಪರ್ಯಾಯವಲ್ಲ; ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ರಚನೆಯೊಂದಿಗೆ, ಉದಾಹರಣೆಗೆ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಟ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಟ್ರೀಸ್ (ASTs) ನೊಂದಿಗೆ ಕೆಲಸ ಮಾಡಬಲ್ಲ ಆಳವಾಗಿ ಸಂಯೋಜಿತ ವ್ಯವಸ್ಥೆಯಾಗಿದೆ.
ಪ್ರಮುಖ ಬಳಕೆಯ ಪ್ರಕರಣಗಳು ಮತ್ತು ಪ್ರಾಯೋಗಿಕ ಉದಾಹರಣೆಗಳು
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನ ನಿಜವಾದ ಶಕ್ತಿಯು ಅವುಗಳು ಸುಲಭವಾಗಿ ಪರಿಹರಿಸಬಲ್ಲ ಸಮಸ್ಯೆಗಳನ್ನು ನೋಡಿದಾಗ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ. ಕೆಲವು ಅತ್ಯಂತ ಪರಿಣಾಮಕಾರಿ ಬಳಕೆಯ ಪ್ರಕರಣಗಳನ್ನು ಅನ್ವೇಷಿಸೋಣ.
ಬಳಕೆಯ ಪ್ರಕರಣ 1: ಸ್ಥಳೀಯ, ಶೂನ್ಯ-ವೆಚ್ಚದ ಟೈಪ್ ಟಿಪ್ಪಣಿಗಳು
ಈ ಪ್ರಸ್ತಾವನೆಯ ಪ್ರಾಥಮಿಕ ಚಾಲಕರಲ್ಲಿ ಒಂದು, TypeScript ಮತ್ತು Flow ನಂತಹ ಟೈಪ್ ಸಿಸ್ಟಮ್‌ಗಳಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಭಾಷೆಯೊಳಗೆ ಸ್ಥಳೀಯ ನೆಲೆಯನ್ನು ಒದಗಿಸುವುದು. ಪ್ರಸ್ತುತ, `import type { ... }` ಒಂದು TypeScript-ನಿರ್ದಿಷ್ಟ ವೈಶಿಷ್ಟ್ಯವಾಗಿದೆ. ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನೊಂದಿಗೆ, ಇದು ಒಂದು ಪ್ರಮಾಣಿತ ಭಾಷಾ ರಚನೆಯಾಗುತ್ತದೆ.
ಪ್ರಸ್ತುತ (TypeScript):
// types.ts
export interface User {
id: number;
name: string;
}
// app.ts
import type { User } from './types';
const user: User = { id: 1, name: 'Alice' };
ಭವಿಷ್ಯ (ಪ್ರಮಾಣಿತ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್):
// types.js
export interface User { /* ... */ } // ಟೈಪ್ ಸಿಂಟ್ಯಾಕ್ಸ್ ಪ್ರಸ್ತಾವನೆಯನ್ನು ಸಹ ಅಳವಡಿಸಿಕೊಳ್ಳಲಾಗಿದೆ ಎಂದು ಭಾವಿಸಿ
// app.js
import source { User } from './types.js';
const user: User = { id: 1, name: 'Alice' };
ಪ್ರಯೋಜನ: import source ಹೇಳಿಕೆಯು ಯಾವುದೇ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಟೂಲ್ ಅಥವಾ ಇಂಜಿನ್‌ಗೆ ./types.js ಒಂದು ಬಿಲ್ಡ್-ಟೈಮ್-ಮಾತ್ರ ಅವಲಂಬನೆ ಎಂದು ಸ್ಪಷ್ಟವಾಗಿ ಹೇಳುತ್ತದೆ. ರನ್‌ಟೈಮ್ ಇಂಜಿನ್ ಅದನ್ನು ತರಲು ಅಥವಾ ಪಾರ್ಸ್ ಮಾಡಲು ಎಂದಿಗೂ ಪ್ರಯತ್ನಿಸುವುದಿಲ್ಲ. ಇದು ಟೈಪ್ ಅಳಿಸುವಿಕೆಯ ಪರಿಕಲ್ಪನೆಯನ್ನು ಪ್ರಮಾಣೀಕರಿಸುತ್ತದೆ, ಅದನ್ನು ಭಾಷೆಯ ಔಪಚಾರಿಕ ಭಾಗವನ್ನಾಗಿ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬಂಡ್ಲರ್‌ಗಳು, ಲಿಂಟರ್‌ಗಳು ಮತ್ತು ಇತರ ಪರಿಕರಗಳ ಕೆಲಸವನ್ನು ಸರಳಗೊಳಿಸುತ್ತದೆ.
ಬಳಕೆಯ ಪ್ರಕರಣ 2: ಶಕ್ತಿಯುತ ಮತ್ತು ಹೈಜೀನಿಕ್ ಮ್ಯಾಕ್ರೋಗಳು
ಮ್ಯಾಕ್ರೋಗಳು ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನ ಅತ್ಯಂತ ಪರಿವರ್ತಕ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ. ಅವು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ವಿಸ್ತರಿಸಲು ಮತ್ತು ಸುರಕ್ಷಿತ ಮತ್ತು ಪ್ರಮಾಣಿತ ರೀತಿಯಲ್ಲಿ ಶಕ್ತಿಯುತ, ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ಭಾಷೆಗಳನ್ನು (DSLs) ರಚಿಸಲು ಅನುವು ಮಾಡಿಕೊಡುತ್ತವೆ.
ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ಫೈಲ್ ಮತ್ತು ಲೈನ್ ಸಂಖ್ಯೆಯನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸೇರಿಸುವ ಸರಳ ಲಾಗಿಂಗ್ ಮ್ಯಾಕ್ರೋವನ್ನು ಕಲ್ಪಿಸಿಕೊಳ್ಳೋಣ.
ಮ್ಯಾಕ್ರೋ ವ್ಯಾಖ್ಯಾನ:
// macros.js
export function log(macroContext) {
// 'macroContext' ಕಾಲ್ ಸೈಟ್ ಅನ್ನು ಪರೀಕ್ಷಿಸಲು API ಗಳನ್ನು ಒದಗಿಸುತ್ತದೆ
const callSite = macroContext.getCallSiteInfo(); // ಉದಾ., { file: 'app.js', line: 5 }
const messageArgument = macroContext.getArgument(0); // ಸಂದೇಶಕ್ಕಾಗಿ AST ಪಡೆಯಿರಿ
// console.log ಕಾಲ್‌ಗಾಗಿ ಹೊಸ AST ಅನ್ನು ಹಿಂತಿರುಗಿಸಿ
return `console.log("[${callSite.file}:${callSite.line}]", ${messageArgument})`;
}
ಮ್ಯಾಕ್ರೋವನ್ನು ಬಳಸುವುದು:
// app.js
import source { log } from './macros.js';
const value = 42;
log(`The value is: ${value}`);
ಕಂಪೈಲ್ಡ್ ರನ್‌ಟೈಮ್ ಕೋಡ್:
// app.js (ಸೋರ್ಸ್ ಫೇಸ್ ನಂತರ)
const value = 42;
console.log("[app.js:5]", `The value is: ${value}`);
ಪ್ರಯೋಜನ: ನಾವು ಹೆಚ್ಚು ಅಭಿವ್ಯಕ್ತಿಶೀಲ `log` ಫಂಕ್ಷನ್ ಅನ್ನು ರಚಿಸಿದ್ದೇವೆ, ಅದು ಬಿಲ್ಡ್-ಟೈಮ್ ಮಾಹಿತಿಯನ್ನು ನೇರವಾಗಿ ರನ್‌ಟೈಮ್ ಕೋಡ್‌ಗೆ ಸೇರಿಸುತ್ತದೆ. ರನ್‌ಟೈಮ್‌ನಲ್ಲಿ ಯಾವುದೇ `log` ಫಂಕ್ಷನ್ ಕಾಲ್ ಇಲ್ಲ, ಕೇವಲ ನೇರ `console.log`. ಇದು ನಿಜವಾದ ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್ ಆಗಿದೆ. ಇದೇ ತತ್ವವನ್ನು JSX, ಸ್ಟೈಲ್ಡ್-ಕಾಂಪೊನೆಂಟ್ಸ್, ಅಂತರರಾಷ್ಟ್ರೀಕರಣ (i18n) ಲೈಬ್ರರಿಗಳು ಮತ್ತು ಹೆಚ್ಚಿನದನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಬಳಸಬಹುದು, ಎಲ್ಲವೂ ಕಸ್ಟಮ್ Babel ಪ್ಲಗಿನ್‌ಗಳಿಲ್ಲದೆ.
ಬಳಕೆಯ ಪ್ರಕರಣ 3: ಸಂಯೋಜಿತ ಬಿಲ್ಡ್-ಟೈಮ್ ಕೋಡ್ ಜನರೇಷನ್
ಅನೇಕ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ಇತರ ಮೂಲಗಳಿಂದ ಕೋಡ್ ಉತ್ಪಾದಿಸುವುದರ ಮೇಲೆ ಅವಲಂಬಿತವಾಗಿವೆ, ಉದಾಹರಣೆಗೆ GraphQL ಸ್ಕೀಮಾ, ಪ್ರೊಟೊಕಾಲ್ ಬಫರ್ಸ್ ವ್ಯಾಖ್ಯಾನ, ಅಥವಾ YAML ಅಥವಾ JSON ನಂತಹ ಸರಳ ಡೇಟಾ ಫೈಲ್.
ನಿಮ್ಮ ಬಳಿ GraphQL ಸ್ಕೀಮಾ ಇದೆ ಮತ್ತು ನೀವು ಅದಕ್ಕಾಗಿ ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ಕ್ಲೈಂಟ್ ಅನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ ಎಂದು ಕಲ್ಪಿಸಿಕೊಳ್ಳಿ. ಇಂದು, ಇದಕ್ಕೆ ಬಾಹ್ಯ CLI ಪರಿಕರಗಳು ಮತ್ತು ಸಂಕೀರ್ಣ ಬಿಲ್ಡ್ ಸೆಟಪ್ ಅಗತ್ಯವಿದೆ. ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನೊಂದಿಗೆ, ಇದು ನಿಮ್ಮ ಮಾಡ್ಯೂಲ್ ಗ್ರಾಫ್‌ನ ಸಂಯೋಜಿತ ಭಾಗವಾಗಬಹುದು.
ಜನರೇಟರ್ ಮಾಡ್ಯೂಲ್:
// graphql-codegen.js
export function createClient(schemaText) {
// 1. ಸ್ಕೀಮಾಟೆಕ್ಸ್ಟ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡಿ
// 2. ಟೈಪ್ಡ್ ಕ್ಲೈಂಟ್‌ಗಾಗಿ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ರಚಿಸಿ
// 3. ರಚಿತವಾದ ಕೋಡ್ ಅನ್ನು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಹಿಂತಿರುಗಿಸಿ
const generatedCode = `
export const client = {
query: { /* ... ರಚಿತವಾದ ವಿಧಾನಗಳು ... */ }
};
`;
return generatedCode;
}
ಜನರೇಟರ್ ಅನ್ನು ಬಳಸುವುದು:
// app.js
// 1. ಇಂಪೋರ್ಟ್ ಅಸರ್ಶನ್ಸ್ ಬಳಸಿ ಸ್ಕೀಮಾವನ್ನು ಟೆಕ್ಸ್ಟ್ ಆಗಿ ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ (ಒಂದು ಪ್ರತ್ಯೇಕ ವೈಶಿಷ್ಟ್ಯ)
import schema from './api.graphql' with { type: 'text' };
// 2. ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ ಬಳಸಿ ಕೋಡ್ ಜನರೇಟರ್ ಅನ್ನು ಆಮದು ಮಾಡಿಕೊಳ್ಳಿ
import source { createClient } from './graphql-codegen.js';
// 3. ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ಜನರೇಟರ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಿ ಮತ್ತು ಅದರ ಔಟ್‌ಪುಟ್ ಅನ್ನು ಸೇರಿಸಿ
export const { client } = createClient(schema);
ಪ್ರಯೋಜನ: ಸಂಪೂರ್ಣ ಪ್ರಕ್ರಿಯೆಯು ಘೋಷಣಾತ್ಮಕವಾಗಿದೆ ಮತ್ತು ಸೋರ್ಸ್ ಕೋಡ್‌ನ ಭಾಗವಾಗಿದೆ. ಬಾಹ್ಯ ಕೋಡ್ ಜನರೇಟರ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು ಇನ್ನು ಮುಂದೆ ಪ್ರತ್ಯೇಕ, ಹಸ್ತಚಾಲಿತ ಹಂತವಲ್ಲ. `api.graphql` ಬದಲಾದರೆ, `app.js` ಗಾಗಿ ಸೋರ್ಸ್ ಫೇಸ್ ಅನ್ನು ಮರು-ಚಲಾಯಿಸಬೇಕೆಂದು ಬಿಲ್ಡ್ ಟೂಲ್‌ಗೆ ಸ್ವಯಂಚಾಲಿತವಾಗಿ ತಿಳಿದಿರುತ್ತದೆ. ಇದು ಅಭಿವೃದ್ಧಿ ಕೆಲಸದ ಹರಿವನ್ನು ಸರಳ, ಹೆಚ್ಚು ದೃಢ ಮತ್ತು ಕಡಿಮೆ ದೋಷ-ಪೀಡಿತವಾಗಿಸುತ್ತದೆ.
ಇದು ಹೇಗೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ: ಹೋಸ್ಟ್, ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್, ಮತ್ತು ಹಂತಗಳು
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್ ಸ್ವತಃ (Chrome ಮತ್ತು Node.js ನಲ್ಲಿ V8 ನಂತೆ) ಸೋರ್ಸ್ ಫೇಸ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವುದಿಲ್ಲ ಎಂಬುದನ್ನು ಅರ್ಥಮಾಡಿಕೊಳ್ಳುವುದು ಬಹಳ ಮುಖ್ಯ. ಜವಾಬ್ದಾರಿಯು ಹೋಸ್ಟ್ ಪರಿಸರದ ಮೇಲೆ ಬೀಳುತ್ತದೆ.
ಹೋಸ್ಟ್‌ನ ಪಾತ್ರ
ಹೋಸ್ಟ್ ಎನ್ನುವುದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಕೋಡ್ ಅನ್ನು ಕಂಪೈಲ್ ಮಾಡುತ್ತಿರುವ ಅಥವಾ ಚಲಾಯಿಸುತ್ತಿರುವ ಪ್ರೋಗ್ರಾಂ ಆಗಿದೆ. ಇದು ಹೀಗಿರಬಹುದು:
- Vite, Webpack, ಅಥವಾ Parcel ನಂತಹ ಬಂಡ್ಲರ್.
- Node.js ಅಥವಾ Deno ನಂತಹ ರನ್‌ಟೈಮ್.
- ಒಂದು ಬ್ರೌಸರ್ ಕೂಡ ತನ್ನ DevTools ನಲ್ಲಿ ಅಥವಾ ಡೆವಲಪ್‌ಮೆಂಟ್ ಸರ್ವರ್ ಬಿಲ್ಡ್ ಪ್ರಕ್ರಿಯೆಯ ಸಮಯದಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳ್ಳುವ ಕೋಡ್‌ಗಾಗಿ ಹೋಸ್ಟ್ ಆಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸಬಹುದು.
ಹೋಸ್ಟ್ ಎರಡು-ಹಂತದ ಪ್ರಕ್ರಿಯೆಯನ್ನು ಸಂಘಟಿಸುತ್ತದೆ:
- ಇದು ಕೋಡ್ ಅನ್ನು ಪಾರ್ಸ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಎಲ್ಲಾ
import sourceಘೋಷಣೆಗಳನ್ನು ಪತ್ತೆ ಮಾಡುತ್ತದೆ. - ಇದು ಸೋರ್ಸ್ ಫೇಸ್ ಮಾಡ್ಯೂಲ್‌ಗಳನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ವಿಶೇಷವಾಗಿ ಪ್ರತ್ಯೇಕವಾದ, ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್ ಮಾಡಿದ ಪರಿಸರವನ್ನು (ಆಗಾಗ್ಗೆ "Realm" ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ) ರಚಿಸುತ್ತದೆ.
- ಇದು ಆಮದು ಮಾಡಿಕೊಂಡ ಸೋರ್ಸ್ ಮಾಡ್ಯೂಲ್‌ಗಳಿಂದ ಕೋಡ್ ಅನ್ನು ಈ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಕಾರ್ಯಗತಗೊಳಿಸುತ್ತದೆ. ಈ ಮಾಡ್ಯೂಲ್‌ಗಳಿಗೆ ಅವುಗಳು ರೂಪಾಂತರಿಸುತ್ತಿರುವ ಕೋಡ್‌ನೊಂದಿಗೆ ಸಂವಹನ ನಡೆಸಲು ವಿಶೇಷ API ಗಳನ್ನು ನೀಡಲಾಗುತ್ತದೆ (ಉದಾ., AST ಮ್ಯಾನಿಪ್ಯುಲೇಷನ್ API ಗಳು).
- ರೂಪಾಂತರಗಳನ್ನು ಅನ್ವಯಿಸಲಾಗುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಅಂತಿಮ ರನ್‌ಟೈಮ್ ಕೋಡ್ ದೊರೆಯುತ್ತದೆ.
- ಈ ಅಂತಿಮ ಕೋಡ್ ಅನ್ನು ನಂತರ ರನ್‌ಟೈಮ್ ಹಂತಕ್ಕಾಗಿ ಸಾಮಾನ್ಯ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಇಂಜಿನ್‌ಗೆ ರವಾನಿಸಲಾಗುತ್ತದೆ.
ಭದ್ರತೆ ಮತ್ತು ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸಿಂಗ್ ನಿರ್ಣಾಯಕವಾಗಿವೆ
ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ಕೋಡ್ ಅನ್ನು ಚಲಾಯಿಸುವುದು ಸಂಭಾವ್ಯ ಭದ್ರತಾ ಅಪಾಯಗಳನ್ನು ಪರಿಚಯಿಸುತ್ತದೆ. ದುರುದ್ದೇಶಪೂರಿತ ಬಿಲ್ಡ್-ಟೈಮ್ ಸ್ಕ್ರಿಪ್ಟ್ ಡೆವಲಪರ್‌ನ ಯಂತ್ರದಲ್ಲಿ ಫೈಲ್‌ಸಿಸ್ಟಮ್ ಅಥವಾ ನೆಟ್‌ವರ್ಕ್ ಅನ್ನು ಪ್ರವೇಶಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು. ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ ಪ್ರಸ್ತಾವನೆಯು ಭದ್ರತೆಗೆ ಬಲವಾದ ಒತ್ತು ನೀಡುತ್ತದೆ.
ಸೋರ್ಸ್ ಫೇಸ್ ಕೋಡ್ ಹೆಚ್ಚು ನಿರ್ಬಂಧಿತ ಸ್ಯಾಂಡ್‌ಬಾಕ್ಸ್‌ನಲ್ಲಿ ಚಲಿಸುತ್ತದೆ. ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ, ಇದಕ್ಕೆ ಇವುಗಳಿಗೆ ಪ್ರವೇಶವಿಲ್ಲ:
- ಸ್ಥಳೀಯ ಫೈಲ್‌ಸಿಸ್ಟಮ್.
- ನೆಟ್‌ವರ್ಕ್ ವಿನಂತಿಗಳು.
windowಅಥವಾprocessನಂತಹ ರನ್‌ಟೈಮ್ ಗ್ಲೋಬಲ್‌ಗಳು.
ಫೈಲ್ ಪ್ರವೇಶದಂತಹ ಯಾವುದೇ ಸಾಮರ್ಥ್ಯಗಳನ್ನು ಹೋಸ್ಟ್ ಪರಿಸರದಿಂದ ಸ್ಪಷ್ಟವಾಗಿ ನೀಡಬೇಕಾಗುತ್ತದೆ, ಬಳಕೆದಾರರಿಗೆ ಬಿಲ್ಡ್-ಟೈಮ್ ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳು ಏನು ಮಾಡಲು ಅನುಮತಿಸಲಾಗಿದೆ ಎಂಬುದರ ಮೇಲೆ ಸಂಪೂರ್ಣ ನಿಯಂತ್ರಣವನ್ನು ನೀಡುತ್ತದೆ. ಇದು ಪ್ರಸ್ತುತ ಪ್ಲಗಿನ್‌ಗಳು ಮತ್ತು ಸ್ಕ್ರಿಪ್ಟ್‌ಗಳ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗಿಂತ ಹೆಚ್ಚು ಸುರಕ್ಷಿತವಾಗಿದೆ, ಅವುಗಳು ಆಗಾಗ್ಗೆ ಸಿಸ್ಟಮ್‌ಗೆ ಸಂಪೂರ್ಣ ಪ್ರವೇಶವನ್ನು ಹೊಂದಿರುತ್ತವೆ.
ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯ ಮೇಲೆ ಜಾಗತಿಕ ಪರಿಣಾಮ
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್‌ನ ಪರಿಚಯವು ಇಡೀ ಜಾಗತಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಯಾದ್ಯಂತ ಅಲೆಗಳನ್ನು ಕಳುಹಿಸುತ್ತದೆ, ನಾವು ಪರಿಕರಗಳು, ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ಮತ್ತು ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ನಿರ್ಮಿಸುವ ವಿಧಾನವನ್ನು ಮೂಲಭೂತವಾಗಿ ಬದಲಾಯಿಸುತ್ತದೆ.
ಫ್ರೇಮ್‌ವರ್ಕ್ ಮತ್ತು ಲೈಬ್ರರಿ ಲೇಖಕರಿಗೆ
React, Svelte, Vue, ಮತ್ತು Solid ನಂತಹ ಫ್ರೇಮ್‌ವರ್ಕ್‌ಗಳು ತಮ್ಮ ಕಂಪೈಲರ್‌ಗಳನ್ನು ಭಾಷೆಯ ಭಾಗವನ್ನಾಗಿ ಮಾಡಲು ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ ಅನ್ನು ಬಳಸಿಕೊಳ್ಳಬಹುದು. Svelte ಕಂಪೈಲರ್, ಇದು Svelte ಕಾಂಪೊನೆಂಟ್‌ಗಳನ್ನು ಆಪ್ಟಿಮೈಸ್ ಮಾಡಿದ ವೆನಿಲ್ಲಾ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಇದನ್ನು ಮ್ಯಾಕ್ರೋ ಆಗಿ ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು. JSX ಒಂದು ಪ್ರಮಾಣಿತ ಮ್ಯಾಕ್ರೋ ಆಗಬಹುದು, ಪ್ರತಿ ಟೂಲ್‌ಗೂ ತನ್ನದೇ ಆದ ಕಸ್ಟಮ್ ಟ್ರಾನ್ಸ್‌ಫಾರ್ಮ್ ಅನುಷ್ಠಾನದ ಅಗತ್ಯವನ್ನು ತೆಗೆದುಹಾಕುತ್ತದೆ.
CSS-in-JS ಲೈಬ್ರರಿಗಳು ತಮ್ಮ ಎಲ್ಲಾ ಸ್ಟೈಲ್ ಪಾರ್ಸಿಂಗ್ ಮತ್ತು ಸ್ಥಿರ ನಿಯಮ ಉತ್ಪಾದನೆಯನ್ನು ಬಿಲ್ಡ್ ಸಮಯದಲ್ಲಿ ನಿರ್ವಹಿಸಬಹುದು, ಕನಿಷ್ಠ ರನ್‌ಟೈಮ್ ಅಥವಾ ಶೂನ್ಯ ರನ್‌ಟೈಮ್ ಅನ್ನು ಕಳುಹಿಸಬಹುದು, ಇದು ಗಮನಾರ್ಹ ಕಾರ್ಯಕ್ಷಮತೆಯ ಸುಧಾರಣೆಗಳಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.
ಟೂಲಿಂಗ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ
Vite, Webpack, esbuild, ಮತ್ತು ಇತರರ ರಚನೆಕಾರರಿಗೆ, ಈ ಪ್ರಸ್ತಾವನೆಯು ಶಕ್ತಿಯುತ, ಪ್ರಮಾಣಿತ ವಿಸ್ತರಣಾ ಬಿಂದುವನ್ನು ನೀಡುತ್ತದೆ. ಪರಿಕರಗಳ ನಡುವೆ ಭಿನ್ನವಾಗಿರುವ ಸಂಕೀರ್ಣ ಪ್ಲಗಿನ್ API ಅನ್ನು ಅವಲಂಬಿಸುವ ಬದಲು, ಅವರು ಭಾಷೆಯ ಸ್ವಂತ ಬಿಲ್ಡ್-ಟೈಮ್ ಹಂತಕ್ಕೆ ನೇರವಾಗಿ ಸಂಪರ್ಕಿಸಬಹುದು. ಇದು ಹೆಚ್ಚು ಏಕೀಕೃತ ಮತ್ತು ಪರಸ್ಪರ ಕಾರ್ಯಸಾಧ್ಯವಾದ ಟೂಲಿಂಗ್ ಪರಿಸರ ವ್ಯವಸ್ಥೆಗೆ ಕಾರಣವಾಗಬಹುದು, ಅಲ್ಲಿ ಒಂದು ಟೂಲ್‌ಗಾಗಿ ಬರೆದ ಮ್ಯಾಕ್ರೋ ಇನ್ನೊಂದರಲ್ಲಿ ಮನಬಂದಂತೆ ಕೆಲಸ ಮಾಡುತ್ತದೆ.
ಅಪ್ಲಿಕೇಶನ್ ಡೆವಲಪರ್‌ಗಳಿಗೆ
ಪ್ರತಿದಿನ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅಪ್ಲಿಕೇಶನ್‌ಗಳನ್ನು ಬರೆಯುವ ಲಕ್ಷಾಂತರ ಡೆವಲಪರ್‌ಗಳಿಗೆ, ಪ್ರಯೋಜನಗಳು ಹಲವಾರು:
- ಸರಳವಾದ ಬಿಲ್ಡ್ ಕಾನ್ಫಿಗರೇಶನ್‌ಗಳು: TypeScript, JSX, ಅಥವಾ ಕೋಡ್ ಜನರೇಷನ್ ಅನ್ನು ನಿರ್ವಹಿಸುವಂತಹ ಸಾಮಾನ್ಯ ಕಾರ್ಯಗಳಿಗಾಗಿ ಸಂಕೀರ್ಣ ಪ್ಲಗಿನ್‌ಗಳ ಸರಪಳಿಗಳ ಮೇಲೆ ಕಡಿಮೆ ಅವಲಂಬನೆ.
- ಸುಧಾರಿತ ಕಾರ್ಯಕ್ಷಮತೆ: ನಿಜವಾದ ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್‌ಗಳು ಸಣ್ಣ ಬಂಡಲ್ ಗಾತ್ರಗಳಿಗೆ ಮತ್ತು ವೇಗದ ರನ್‌ಟೈಮ್ ಕಾರ್ಯಗತಗೊಳಿಸುವಿಕೆಗೆ ಕಾರಣವಾಗುತ್ತವೆ.
- ವರ್ಧಿತ ಡೆವಲಪರ್ ಅನುಭವ: ಭಾಷೆಗೆ ಕಸ್ಟಮ್, ಡೊಮೇನ್-ನಿರ್ದಿಷ್ಟ ವಿಸ್ತರಣೆಗಳನ್ನು ರಚಿಸುವ ಸಾಮರ್ಥ್ಯವು ಅಭಿವ್ಯಕ್ತಿಯ ಹೊಸ ಮಟ್ಟಗಳನ್ನು ಅನ್ಲಾಕ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಬಾಯ್ಲರ್‌ಪ್ಲೇಟ್ ಅನ್ನು ಕಡಿಮೆ ಮಾಡುತ್ತದೆ.
ಪ್ರಸ್ತುತ ಸ್ಥಿತಿ ಮತ್ತು ಮುಂದಿನ ದಾರಿ
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ TC39 ನಿಂದ ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗುತ್ತಿರುವ ಒಂದು ಪ್ರಸ್ತಾವನೆಯಾಗಿದೆ, ಇದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಅನ್ನು ಪ್ರಮಾಣೀಕರಿಸುವ ಸಮಿತಿಯಾಗಿದೆ. TC39 ಪ್ರಕ್ರಿಯೆಯು ನಾಲ್ಕು ಮುಖ್ಯ ಹಂತಗಳನ್ನು ಹೊಂದಿದೆ, ಹಂತ 1 (ಪ್ರಸ್ತಾವನೆ) ರಿಂದ ಹಂತ 4 (ಮುಗಿದಿದೆ ಮತ್ತು ಭಾಷೆಯಲ್ಲಿ ಸೇರಿಸಲು ಸಿದ್ಧವಾಗಿದೆ).
2023 ರ ಕೊನೆಯಲ್ಲಿ, "ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್" ಪ್ರಸ್ತಾವನೆಯು (ಅದರ ಪ್ರತಿರೂಪವಾದ ಮ್ಯಾಕ್ರೋಗಳೊಂದಿಗೆ) ಹಂತ 2 ರಲ್ಲಿದೆ. ಇದರರ್ಥ ಸಮಿತಿಯು ಕರಡನ್ನು ಅಂಗೀಕರಿಸಿದೆ ಮತ್ತು ವಿವರವಾದ ನಿರ್ದಿಷ್ಟತೆಯ ಮೇಲೆ ಸಕ್ರಿಯವಾಗಿ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತಿದೆ. ಮೂಲ ಸಿಂಟ್ಯಾಕ್ಸ್ ಮತ್ತು ಸೆಮ್ಯಾಂಟಿಕ್ಸ್ ಹೆಚ್ಚಾಗಿ ಇತ್ಯರ್ಥಗೊಂಡಿವೆ, ಮತ್ತು ಇದು ಪ್ರತಿಕ್ರಿಯೆಯನ್ನು ಒದಗಿಸಲು ಆರಂಭಿಕ ಅನುಷ್ಠಾನಗಳು ಮತ್ತು ಪ್ರಯೋಗಗಳನ್ನು ಪ್ರೋತ್ಸಾಹಿಸುವ ಹಂತವಾಗಿದೆ.
ಇದರರ್ಥ ನೀವು ಇಂದು ನಿಮ್ಮ ಬ್ರೌಸರ್ ಅಥವಾ Node.js ಪ್ರಾಜೆಕ್ಟ್‌ನಲ್ಲಿ import source ಅನ್ನು ಬಳಸಲು ಸಾಧ್ಯವಿಲ್ಲ. ಆದಾಗ್ಯೂ, ಪ್ರಸ್ತಾವನೆಯು ಹಂತ 3 ರತ್ತ ಪ್ರಬುದ್ಧವಾಗುತ್ತಿದ್ದಂತೆ, ಅತ್ಯಾಧುನಿಕ ಬಿಲ್ಡ್ ಪರಿಕರಗಳು ಮತ್ತು ಟ್ರಾನ್ಸ್‌ಪೈಲರ್‌ಗಳಲ್ಲಿ ಪ್ರಾಯೋಗಿಕ ಬೆಂಬಲವು ಶೀಘ್ರದಲ್ಲೇ ಕಾಣಿಸಿಕೊಳ್ಳುವುದನ್ನು ನಾವು ನಿರೀಕ್ಷಿಸಬಹುದು. ಮಾಹಿತಿ ಪಡೆಯಲು ಉತ್ತಮ ಮಾರ್ಗವೆಂದರೆ GitHub ನಲ್ಲಿ ಅಧಿಕೃತ TC39 ಪ್ರಸ್ತಾವನೆಗಳನ್ನು ಅನುಸರಿಸುವುದು.
ತೀರ್ಮಾನ: ಭವಿಷ್ಯವು ಬಿಲ್ಡ್-ಟೈಮ್ ಆಗಿದೆ
ಸೋರ್ಸ್ ಫೇಸ್ ಇಂಪೋರ್ಟ್ಸ್ ES ಮಾಡ್ಯೂಲ್‌ಗಳ ಪರಿಚಯದ ನಂತರ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ಇತಿಹಾಸದಲ್ಲಿನ ಅತ್ಯಂತ ಮಹತ್ವದ ವಾಸ್ತುಶಿಲ್ಪದ ಬದಲಾವಣೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಪ್ರತಿನಿಧಿಸುತ್ತದೆ. ಬಿಲ್ಡ್-ಟೈಮ್ ಮತ್ತು ರನ್‌ಟೈಮ್ ನಡುವೆ ಔಪಚಾರಿಕ, ಪ್ರಮಾಣಿತ ಪ್ರತ್ಯೇಕತೆಯನ್ನು ರಚಿಸುವ ಮೂಲಕ, ಪ್ರಸ್ತಾವನೆಯು ಭಾಷೆಯಲ್ಲಿನ ಮೂಲಭೂತ ಅಂತರವನ್ನು ಪರಿಹರಿಸುತ್ತದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳು ದೀರ್ಘಕಾಲದಿಂದ ಬಯಸಿದ ಸಾಮರ್ಥ್ಯಗಳನ್ನು — ಮ್ಯಾಕ್ರೋಗಳು, ಕಂಪೈಲ್-ಟೈಮ್ ಮೆಟಾಪ್ರೋಗ್ರಾಮಿಂಗ್, ಮತ್ತು ನಿಜವಾದ ಶೂನ್ಯ-ವೆಚ್ಚದ ಅಬ್‌ಸ್ಟ್ರ್ಯಾಕ್ಷನ್‌ಗಳನ್ನು — ಕಸ್ಟಮ್, ವಿಭಜಿತ ಟೂಲಿಂಗ್ ಕ್ಷೇತ್ರದಿಂದ ಹೊರತಂದು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನ ತಿರುಳಿಗೆ ತರುತ್ತದೆ.
ಇದು ಕೇವಲ ಹೊಸ ಸಿಂಟ್ಯಾಕ್ಸ್‌ನ ತುಣುಕಲ್ಲ; ಇದು ನಾವು ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್‌ನೊಂದಿಗೆ ಸಾಫ್ಟ್‌ವೇರ್ ಅನ್ನು ಹೇಗೆ ನಿರ್ಮಿಸುತ್ತೇವೆ ಎಂಬುದರ ಬಗ್ಗೆ ಯೋಚಿಸುವ ಹೊಸ ವಿಧಾನವಾಗಿದೆ. ಇದು ಡೆವಲಪರ್‌ಗಳಿಗೆ ಬಳಕೆದಾರರ ಸಾಧನದಿಂದ ಡೆವಲಪರ್‌ನ ಯಂತ್ರಕ್ಕೆ ಹೆಚ್ಚಿನ ತರ್ಕವನ್ನು ಸರಿಸಲು ಅಧಿಕಾರ ನೀಡುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಹೆಚ್ಚು ಶಕ್ತಿಯುತ ಮತ್ತು ಅಭಿವ್ಯಕ್ತಿಶೀಲ ಮಾತ್ರವಲ್ಲದೆ ವೇಗವಾದ ಮತ್ತು ಹೆಚ್ಚು ಪರಿಣಾಮಕಾರಿಯಾದ ಅಪ್ಲಿಕೇಶನ್‌ಗಳು ದೊರೆಯುತ್ತವೆ. ಪ್ರಸ್ತಾವನೆಯು ಪ್ರಮಾಣೀಕರಣದತ್ತ ತನ್ನ ಪ್ರಯಾಣವನ್ನು ಮುಂದುವರೆಸಿದಂತೆ, ಇಡೀ ಜಾಗತಿಕ ಜಾವಾಸ್ಕ್ರಿಪ್ಟ್ ಸಮುದಾಯವು ನಿರೀಕ್ಷೆಯಿಂದ ಗಮನಿಸಬೇಕು. ಬಿಲ್ಡ್-ಟೈಮ್ ನಾವೀನ್ಯತೆಯ ಹೊಸ ಯುಗವು ಹತ್ತಿರದಲ್ಲೇ ಇದೆ.